package com.heihei.serviceimpl.res;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.heihei.common.page.Condition;
import com.heihei.common.page.Query;
import com.heihei.common.response.ResponseVO;
import com.heihei.entity.res.ResTypeEntity;
import com.heihei.enums.DeleteFlagEnum;
import com.heihei.mapper.res.ResTypeMapper;
import com.heihei.service.res.ResTypeService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang.StringUtils;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.stream.Collectors;

/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author duanhengfei
 * @since 2021-11-23
 */
@Service
public class ResTypeServiceImpl extends ServiceImpl<ResTypeMapper, ResTypeEntity> implements ResTypeService {

    /**
     * 添加
     *
     * @author duanhengfei
     * @date 2021年11月30日 22:29:04
     */
    @Override
    public ResponseVO<String> myAdd(ResTypeEntity paramEntity) {
        paramEntity.setId(null);
        if(StringUtils.isEmpty(paramEntity.getTypeName())) {
            return ResponseVO.paramLess("类型名称不能为空");
        }
        //查看是否有重复
        LambdaQueryWrapper<ResTypeEntity> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(ResTypeEntity::getTypeName, paramEntity.getTypeName());
        List<ResTypeEntity> list = this.list(queryWrapper);
        if(CollectionUtils.isNotEmpty(list)) {
            return ResponseVO.paramIllegal("重复的类型名");
        }
        //执行添加操作
        boolean flag = this.save(paramEntity);
        if(!flag) {
            return ResponseVO.paramLess("添加可能有误");
        }
        return ResponseVO.dealSuccess(paramEntity.getId());
    }

    /**
     * 修改
     *
     * @author duanhengfei
     * @date 2021年11月30日 22:35:30
     */
    @Override
    public ResponseVO<Boolean> myUpdateById(ResTypeEntity paramEntity) {
        if(StringUtils.isEmpty(paramEntity.getId())) {
            return ResponseVO.paramLess("主键ID不能为空");
        }
        //修改时，限制只能修改未删除的数据
        UpdateWrapper<ResTypeEntity> updateWrapper = new UpdateWrapper<>();
        updateWrapper.lambda().eq(ResTypeEntity::getId, paramEntity.getId())
                .eq(ResTypeEntity::getDelFlag, DeleteFlagEnum.NOT_DELETED.getKey());
        boolean flag = this.update(paramEntity, updateWrapper);
        if(!flag) {
            return ResponseVO.paramIllegal("可能不存在该记录或者已删除");
        }
        return ResponseVO.dealSuccess(true);
    }

    /**
     * 删除（逻辑删除）
     *
     * @author duanhengfei
     * @date 2021年11月30日 22:39:08
     */
    @Override
    public ResponseVO<Boolean> deleteByIdLogic(String id) {
        if(StringUtils.isEmpty(id)) {
            return ResponseVO.paramLess("请传入要删除的id");
        }
        ResTypeEntity entity = new ResTypeEntity();
        entity.setId(id);
        entity.setDelFlag(DeleteFlagEnum.DELETED.getKey());
        //逻辑删除操作
        boolean flag = this.updateById(entity);
        if(!flag) {
            return ResponseVO.paramIllegal("可能不存在该记录");
        }
        return ResponseVO.dealSuccess(true);
    }

    /**
     * 批量删除
     *
     * @author duanhengfei
     * @date 2021年11月30日 22:43:26
     */
    @Override
    public ResponseVO<Boolean> deleteBatch(List<String> idList) {
        if(CollectionUtils.isEmpty(idList)) {
            return ResponseVO.paramLess("请传入需要删除的ID");
        }
        List<ResTypeEntity> list = idList.stream().map(id -> {
            ResTypeEntity entity = new ResTypeEntity();
            entity.setId(id);
            entity.setDelFlag(DeleteFlagEnum.DELETED.getKey());
            return entity;
        }).collect(Collectors.toList());
        //删除操作
        boolean flag = this.updateBatchById(list);
        if(!flag) {
            return ResponseVO.paramIllegal("可能不存在该记录");
        }
        return ResponseVO.dealSuccess(true);
    }

    /**
     * 列表查询
     *
     * @author duanhengfei
     * @date 2021年11月30日 22:47:48
     */
    @Override
    public ResponseVO<IPage<ResTypeEntity>> myPageList(ResTypeEntity entityParam, Query query) {
        LambdaQueryWrapper<ResTypeEntity> queryWrapper = new LambdaQueryWrapper<>();
        //只查询未删除的数据
        queryWrapper.eq(ResTypeEntity::getDelFlag, DeleteFlagEnum.NOT_DELETED.getKey());
        //可以根据类型名称，模糊检索
        if(StringUtils.isNotEmpty(entityParam.getTypeName())) {
            queryWrapper.like(ResTypeEntity::getTypeName, entityParam.getTypeName());
        }
        IPage<ResTypeEntity> pageList = this.page(Condition.getPage(query), queryWrapper);
        return ResponseVO.dealSuccess(pageList);
    }

    /**
     * 详情
     *
     * @author duanhengfei
     * @date 2021年11月30日 22:50:44
     */
    @Override
    public ResponseVO<ResTypeEntity> myGetById(String id) {
        if(StringUtils.isEmpty(id)) {
            return ResponseVO.paramLess("请传入主键ID");
        }
        ResTypeEntity dataEntity = this.getById(id);
        if(dataEntity == null) {
            return ResponseVO.paramIllegal("可能不存在该条记录");
        }
        if(DeleteFlagEnum.DELETED.getKey().equals(dataEntity.getDelFlag())) {
            return ResponseVO.paramIllegal("该条记录已经被删除");
        }
        return ResponseVO.dealSuccess(dataEntity);
    }
}
